/**
 * Tauri文件系统路径持久化服务
 * 用于保存和恢复Tauri环境下的文件路径
 */

/**
 * 存储的路径条目
 */
interface StoredPathEntry {
    path: string;
    name: string;
    lastAccessed: number;
    isDirectory: boolean;
}

/**
 * Tauri持久化管理器
 * 管理文件路径的存储和恢复
 */
export class TauriPersistenceManager {
    private static readonly STORAGE_KEY = 'tauri_fs_paths';
    private static readonly MAX_ENTRIES = 10; // 最多存储的路径数量
    private static readonly FS_CACHE_KEY = 'tauri_fs_cache';
    private static readonly CACHE_EXPIRY = 60 * 60 * 1000; // 缓存有效期1小时

    /**
     * 保存文件路径到持久存储
     * @param path 文件路径
     * @param name 文件名称
     * @param isDirectory 是否为目录
     */
    static savePath(path: string, name: string, isDirectory: boolean): void {
        if (!path || !name) return;
        
        try {
            // 获取现有存储的路径
            const storedPaths = this.getStoredPaths();
            
            // 创建新的路径条目
            const entry: StoredPathEntry = {
                path,
                name,
                lastAccessed: Date.now(),
                isDirectory
            };
            
            // 检查是否已存在相同路径
            const existingIndex = storedPaths.findIndex(p => p.path === path);
            if (existingIndex >= 0) {
                // 更新现有条目访问时间
                storedPaths[existingIndex].lastAccessed = Date.now();
            } else {
                // 添加新条目
                storedPaths.push(entry);
            }
            
            // 确保不超过最大条目数
            if (storedPaths.length > this.MAX_ENTRIES) {
                // 按上次访问时间排序并移除最旧的
                storedPaths.sort((a, b) => b.lastAccessed - a.lastAccessed);
                storedPaths.splice(this.MAX_ENTRIES);
            }
            
            // 存储到localStorage
            this.saveStoredPaths(storedPaths);
            
            console.log(`保存文件路径: ${path}`);
        } catch (error) {
            console.error('保存文件路径失败:', error);
        }
    }
    
    /**
     * 获取最近使用的文件夹路径
     * @returns 最近使用的文件夹路径列表
     */
    static getRecentPaths(directoryOnly = true): StoredPathEntry[] {
        const paths = this.getStoredPaths();
        return paths
            .filter(p => !directoryOnly || p.isDirectory)
            .sort((a, b) => b.lastAccessed - a.lastAccessed);
    }
    
    /**
     * 缓存目录内容提高性能
     * @param path 目录路径
     * @param contents 目录内容列表
     */
    static cacheDirectoryContents(path: string, contents: any[]): void {
        try {
            // 获取现有缓存
            const fsCache = this.getFileSystemCache();
            
            // 更新缓存
            fsCache[path] = {
                contents: contents,
                timestamp: Date.now()
            };
            
            // 清理过期缓存
            this.cleanExpiredCache(fsCache);
            
            // 保存缓存
            localStorage.setItem(this.FS_CACHE_KEY, JSON.stringify(fsCache));
        } catch (error) {
            console.error('缓存目录内容失败:', error);
        }
    }
    
    /**
     * 获取缓存的目录内容
     * @param path 目录路径
     * @returns 目录内容或null（如果没有缓存或缓存已过期）
     */
    static getCachedDirectoryContents(path: string): any[] | null {
        try {
            // 获取缓存
            const fsCache = this.getFileSystemCache();
            const cached = fsCache[path];
            
            // 检查缓存是否存在且未过期
            if (cached && (Date.now() - cached.timestamp < this.CACHE_EXPIRY)) {
                return cached.contents;
            }
            
            return null;
        } catch (error) {
            console.error('获取缓存目录内容失败:', error);
            return null;
        }
    }
    
    /**
     * 清除特定路径的缓存
     * @param path 路径
     */
    static invalidateCache(path: string): void {
        try {
            // 获取现有缓存
            const fsCache = this.getFileSystemCache();
            
            // 删除指定路径的缓存
            delete fsCache[path];
            
            // 保存缓存
            localStorage.setItem(this.FS_CACHE_KEY, JSON.stringify(fsCache));
        } catch (error) {
            console.error('清除缓存失败:', error);
        }
    }
    
    /**
     * 获取存储的路径列表
     */
    private static getStoredPaths(): StoredPathEntry[] {
        try {
            const stored = localStorage.getItem(this.STORAGE_KEY);
            if (!stored) return [];
            return JSON.parse(stored);
        } catch (error) {
            console.error('解析存储的路径失败:', error);
            return [];
        }
    }
    
    /**
     * 保存路径列表
     */
    private static saveStoredPaths(paths: StoredPathEntry[]): void {
        try {
            localStorage.setItem(this.STORAGE_KEY, JSON.stringify(paths));
        } catch (error) {
            console.error('保存路径失败:', error);
        }
    }
    
    /**
     * 获取文件系统缓存
     */
    private static getFileSystemCache(): Record<string, { contents: any[], timestamp: number }> {
        try {
            const cache = localStorage.getItem(this.FS_CACHE_KEY);
            if (!cache) return {};
            return JSON.parse(cache);
        } catch (error) {
            console.error('解析文件系统缓存失败:', error);
            return {};
        }
    }
    
    /**
     * 清理过期缓存
     */
    private static cleanExpiredCache(cache: Record<string, { contents: any[], timestamp: number }>): void {
        const now = Date.now();
        for (const path in cache) {
            if (now - cache[path].timestamp > this.CACHE_EXPIRY) {
                delete cache[path];
            }
        }
    }
}

/**
 * Tauri文件系统导出API
 */
export default {
    /**
     * 保存文件路径
     */
    savePath: TauriPersistenceManager.savePath.bind(TauriPersistenceManager),
    
    /**
     * 获取最近使用的路径
     */
    getRecentPaths: TauriPersistenceManager.getRecentPaths.bind(TauriPersistenceManager),
    
    /**
     * 缓存目录内容
     */
    cacheDirectoryContents: TauriPersistenceManager.cacheDirectoryContents.bind(TauriPersistenceManager),
    
    /**
     * 获取缓存的目录内容
     */
    getCachedDirectoryContents: TauriPersistenceManager.getCachedDirectoryContents.bind(TauriPersistenceManager),
    
    /**
     * 清除缓存
     */
    invalidateCache: TauriPersistenceManager.invalidateCache.bind(TauriPersistenceManager)
}; 